package com.dep.util;

import java.security.MessageDigest;
import java.util.UUID;


public class StringUtil {
    /**
     * 验证中文
     */
    private static final String chinese = "[\u0391-\uFFE5]";

    /**
     * 检查字符串是否不为空，
     *
     * @param str 需要判断的字符串
     * @return 布尔值
     */
    public static boolean notNullAndWhitSpace(Object str) {
        if (str == null) {
            return false;
        }
        str = str.toString().trim();
//        if (str.toString().isEmpty()) {
//            return false;
//        }
//        return true;

        return !str.toString().isEmpty();
    }

    /**
     * 判断字符串为空或null <br>
     *
     * @param obj 对象
     * @return boolean true-为空或null,false -不为空
     * @since 1.0
     */
    public static boolean isNullorEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
//        if (("").equals(obj.toString().trim())) {
//            return true;
//        }
//        return false;
        return ("").equals(obj.toString().trim());
    }

    /**
     * 随机生成UUID
     *
     * @return UUID
     */
    public static String getUUIDHexString() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

    /**
     * 根据字符串生成固定UUID
     *
     * @return String
     */
//    public static synchronized String getUUID(String name) {
//        UUID uuid = UUID.nameUUIDFromBytes(name.getBytes());
//        String str = uuid.toString();
//        String uuidStr;
//        uuidStr = str.replace("-", "");
//        return uuidStr;
//    }
    public static String escape(String val) {
        if (val != null && (val.contains("%") || val.contains("_"))) {
            val = val.replaceAll("%", "/%").replaceAll("_", "/_");
        }
        return val;
    }

    public static boolean regexpDate(String date) {
        boolean b = true;
        if (date != null && !date.equals("")) {
            b = date.matches("((((19|20)\\d{2})-(0?(1|[3-9])|1[012])-(0?[1-9]|[12]\\d|30))|(((19|20)\\d{2})-(0?[13578]|1[02])-31)" +
                    "|(((19|20)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|((((19|20)([13579][26]|[2468][048]|0[48]))|(2000))-0?2-29))$");
        }
        return b;
    }

    /**
     * 空字符串检查 Demo:isBlank("a")
     *
     * @param str 需验证的字符串
     * @return return true/false
     */
    public static boolean isBlank(String str) {
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查字符串的长度。
     *
     * @param str       字符串
     * @param length    最大长度
     * @param mandatory false:可为空，true：不能为空。
     * @return true：通过；false：未通过
     */
    public static boolean checkLength(String str, int length, boolean mandatory) {
        // 空字符
        if (str == null || str.trim().length() == 0) {
//            if (mandatory) {
//                return false;
//            }
//            return true;
            return !mandatory;
        }
        int valueLength = getLength(str);
//        if (valueLength > length) {
//            return false;
//        }
//        return true;
        return valueLength <= length;
    }

    /**
     * 获取字符串长度（中文占两位） <br>
     *
     * @param str String
     * @return length
     * @since 1.0
     */
    private static int getLength(String str) {
        int valueLength = 0;
        if (!notNullAndWhitSpace(str)) {
            return valueLength;
        }
        /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
        for (int i = 0; i < str.length(); i++) {
            /* 获取一个字符 */
            String temp = str.substring(i, i + 1);
            /* 判断是否为中文字符 */
            if (temp.matches(chinese)) {
                /* 中文字符长度为2 */
                valueLength += 2;
            } else {
                /* 其他字符长度为1 */
                valueLength += 1;
            }
        }
        return valueLength;
    }

    /**
     * Object2String <br>
     *
     * @param obj 参数
     * @return string
     * @since 1.0
     */
    public static String getString(Object obj) {
        if (isNullorEmpty(obj)) {
            return "";
        }
        return obj.toString();
    }

    public static boolean isCard(String card) {
//        if (card.matches("[^\\\\d+$]{17}[x]") || card.matches("[^\\\\d+$]{15}")) {
//            return true;
//        }
        return card.matches("[^\\\\d+$]{17}[x]") || card.matches("[^\\\\d+$]{15}") || card.matches("[^\\\\d+$]{15,18}");
//        if (!card.matches("[^\\\\d+$]{15,18}")) {
//            return false;
//        } else return true;
    }

    /**
     * 验证是否是中文姓名
     */
    public static boolean isChineseName(String name) {
        return name.matches("[\u4e00-\u9fa5]{2,10}");
//        if (!name.matches("[\u4e00-\u9fa5]{2,10}")) {
//            return false;
//        } else return true;
    }

    /**
     * 按需十六进制转换
     *
     * @param bytes
     * @param pos
     * @param len
     * @return
     */
    public static String toHexString(byte[] bytes, int pos, int len) {
        StringBuffer sb = new StringBuffer(len * 2);
        for (int i = pos; i < pos + len; ++i) {
            sb.append(convertDigit(bytes[i] >> 4));
            sb.append(convertDigit(bytes[i] & 15));
        }
        return sb.toString();
    }

    private static char convertDigit(int value) {
        value &= 15;
        return value >= 10 ? (char) (value - 10 + 97) : (char) (value + 48);
    }

    /**
     * @param inStr string串
     * @return md5
     * @since 1.0
     */
    public static String md5(String inStr) {
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (Exception e) {
            System.out.println(e.toString());
            e.printStackTrace();
            return "";
        }
        char[] charArray = inStr.toCharArray();
        byte[] byteArray = new byte[charArray.length];
        for (int i = 0; i < charArray.length; i++)
            byteArray[i] = (byte) charArray[i];
        byte[] md5Bytes = md5.digest(byteArray);
        StringBuffer hexValue = new StringBuffer();
        for (int i = 0; i < md5Bytes.length; i++) {
            int val = (md5Bytes[i]) & 0xff;
            if (val < 16)
                hexValue.append("0");
            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }

    /**
     * 十六进制转字符
     * @param s
     * @return
     */
    public static String hexStringToString(String s) {
        if (s == null || s.equals("")) {
            return null;
        }
        s = s.replace(" ", "");
        byte[] baKeyword = new byte[s.length() / 2];
        for (int i = 0; i < baKeyword.length; i++) {
            try {
                baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            s = new String(baKeyword, "UTF-8");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }

    public static String strTo16(String s) {
        String str = "";
        for (int i = 0; i < s.length(); i++) {
            int ch = (int) s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str = str + s4;
        }
        return str;
    }
}
